/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controller;

import controller.exceptions.NonexistentEntityException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.ParameterMode;
import javax.persistence.Persistence;
import javax.persistence.StoredProcedureQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import modelo.Usuario;
import modelo.Perfil;
import modelo.Tblusuarioperfil;

/**
 *
 * @author Cesar
 */
public class TblusuarioperfilJpaController implements Serializable {
    
    public TblusuarioperfilJpaController()
    {
        this.emf = Persistence.createEntityManagerFactory("SeguridadPuntoventa1.2PU"); 
    }

    public TblusuarioperfilJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Tblusuarioperfil tblusuarioperfil) {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario fkUsuario = tblusuarioperfil.getFkUsuario();
            if (fkUsuario != null) {
                fkUsuario = em.getReference(fkUsuario.getClass(), fkUsuario.getIdUsuario());
                tblusuarioperfil.setFkUsuario(fkUsuario);
            }
            Perfil fkPerfil = tblusuarioperfil.getFkPerfil();
            if (fkPerfil != null) {
                fkPerfil = em.getReference(fkPerfil.getClass(), fkPerfil.getIdPerfil());
                tblusuarioperfil.setFkPerfil(fkPerfil);
            }
            em.persist(tblusuarioperfil);
            if (fkUsuario != null) {
                fkUsuario.getTblusuarioperfilList().add(tblusuarioperfil);
                fkUsuario = em.merge(fkUsuario);
            }
            if (fkPerfil != null) {
                fkPerfil.getTblusuarioperfilList().add(tblusuarioperfil);
                fkPerfil = em.merge(fkPerfil);
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Tblusuarioperfil tblusuarioperfil) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Tblusuarioperfil persistentTblusuarioperfil = em.find(Tblusuarioperfil.class, tblusuarioperfil.getIdusuarioPerfil());
            Usuario fkUsuarioOld = persistentTblusuarioperfil.getFkUsuario();
            Usuario fkUsuarioNew = tblusuarioperfil.getFkUsuario();
            Perfil fkPerfilOld = persistentTblusuarioperfil.getFkPerfil();
            Perfil fkPerfilNew = tblusuarioperfil.getFkPerfil();
            if (fkUsuarioNew != null) {
                fkUsuarioNew = em.getReference(fkUsuarioNew.getClass(), fkUsuarioNew.getIdUsuario());
                tblusuarioperfil.setFkUsuario(fkUsuarioNew);
            }
            if (fkPerfilNew != null) {
                fkPerfilNew = em.getReference(fkPerfilNew.getClass(), fkPerfilNew.getIdPerfil());
                tblusuarioperfil.setFkPerfil(fkPerfilNew);
            }
            tblusuarioperfil = em.merge(tblusuarioperfil);
            if (fkUsuarioOld != null && !fkUsuarioOld.equals(fkUsuarioNew)) {
                fkUsuarioOld.getTblusuarioperfilList().remove(tblusuarioperfil);
                fkUsuarioOld = em.merge(fkUsuarioOld);
            }
            if (fkUsuarioNew != null && !fkUsuarioNew.equals(fkUsuarioOld)) {
                fkUsuarioNew.getTblusuarioperfilList().add(tblusuarioperfil);
                fkUsuarioNew = em.merge(fkUsuarioNew);
            }
            if (fkPerfilOld != null && !fkPerfilOld.equals(fkPerfilNew)) {
                fkPerfilOld.getTblusuarioperfilList().remove(tblusuarioperfil);
                fkPerfilOld = em.merge(fkPerfilOld);
            }
            if (fkPerfilNew != null && !fkPerfilNew.equals(fkPerfilOld)) {
                fkPerfilNew.getTblusuarioperfilList().add(tblusuarioperfil);
                fkPerfilNew = em.merge(fkPerfilNew);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = tblusuarioperfil.getIdusuarioPerfil();
                if (findTblusuarioperfil(id) == null) {
                    throw new NonexistentEntityException("The tblusuarioperfil with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Tblusuarioperfil tblusuarioperfil;
            try {
                tblusuarioperfil = em.getReference(Tblusuarioperfil.class, id);
                tblusuarioperfil.getIdusuarioPerfil();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The tblusuarioperfil with id " + id + " no longer exists.", enfe);
            }
            Usuario fkUsuario = tblusuarioperfil.getFkUsuario();
            if (fkUsuario != null) {
                fkUsuario.getTblusuarioperfilList().remove(tblusuarioperfil);
                fkUsuario = em.merge(fkUsuario);
            }
            Perfil fkPerfil = tblusuarioperfil.getFkPerfil();
            if (fkPerfil != null) {
                fkPerfil.getTblusuarioperfilList().remove(tblusuarioperfil);
                fkPerfil = em.merge(fkPerfil);
            }
            em.remove(tblusuarioperfil);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Tblusuarioperfil> findTblusuarioperfilEntities() {
        return findTblusuarioperfilEntities(true, -1, -1);
    }

    public List<Tblusuarioperfil> findTblusuarioperfilEntities(int maxResults, int firstResult) {
        return findTblusuarioperfilEntities(false, maxResults, firstResult);
    }

    private List<Tblusuarioperfil> findTblusuarioperfilEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Tblusuarioperfil.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Tblusuarioperfil findTblusuarioperfil(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Tblusuarioperfil.class, id);
        } finally {
            em.close();
        }
    }

    public int getTblusuarioperfilCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Tblusuarioperfil> rt = cq.from(Tblusuarioperfil.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
    
    //Metodos Cesar
    
    public List<Tblusuarioperfil> selectUsuarioLogin(Usuario _usuario)    
    {        
        List<Tblusuarioperfil> listUsuarioPerfil = new ArrayList<Tblusuarioperfil>();
        Usuario user = new Usuario();
        Perfil per = new Perfil();
        Tblusuarioperfil usPerf = new Tblusuarioperfil();
        
        try
        {
            EntityManager  em =  getEntityManager();
            Query query = em.createNativeQuery("{call sp_selectUsuarioLogin(?,?)}");
            query.setParameter(1, _usuario.getNombreUsuario()).setParameter(2, _usuario.getContrasenia());                      
            List<Object[]> listaUsuario = query.getResultList();
                                    
            
            for(int i=0; i<listaUsuario.size(); i++)
            {
                Object[] objList = (Object[])listaUsuario.get(i);
                
                
                user.setNombreUsuario(objList[0].toString());
                user.setContrasenia(objList[1].toString());
                
                usPerf.setFkUsuario(user);                               
                listUsuarioPerfil.add(usPerf);                
            }            
            
            em.close();
            return listUsuarioPerfil;        
        }
        catch(Exception ex)
        {            
            System.out.print("el error es "+ ex.getMessage());
            return null;        
        }
    
    }
           
    public boolean insertarTblusuarioperfil(Usuario _us, Perfil _per)
    {
        
        try
        {                        
            EntityManager em = emf.createEntityManager();            
            // Create Call stored procedure
            em.getTransaction().begin();
            StoredProcedureQuery procedure = em.createStoredProcedureQuery("sp_insertUsuarioPerfil", Usuario.class);            
            // Set Parameters
            procedure.registerStoredProcedureParameter("_idUsuario", int.class, ParameterMode.IN);
            procedure.registerStoredProcedureParameter("_idPerfil", int.class, ParameterMode.IN);
            
            procedure.setParameter("_idUsuario", _us.getIdUsuario());
            procedure.setParameter("_idPerfil", _per.getIdPerfil());
            
            // Execute SP
            boolean respuesta = procedure.execute();
            // Get Result                        
            em.getTransaction().commit();
            em.close();                        
        return respuesta;        
            
        }
        catch(Exception ex)
        {
            System.out.print("el error es "+ ex.getMessage());
            return false;        
        }
    
    }
    
    public List<Tblusuarioperfil> selectAllTblUsuarioPerfil()
    {        
        try
        {
            EntityManager em = emf.createEntityManager();            
            // Create Call stored procedure
            em.getTransaction().begin();
            StoredProcedureQuery procedure = em.createStoredProcedureQuery("sp_selectAllUsuariosPerfil", Tblusuarioperfil.class);            
            // Get Result
            List<Tblusuarioperfil> listUsuarioperfil = procedure.getResultList();
            // Commit and Close
            em.getTransaction().commit();
            em.close();
            // return List
            return listUsuarioperfil;
        
        }
        catch(Exception ex)
        {
            System.out.print("el error es "+ ex.getMessage());
            return null;  
        }        
    }
    
    public List<Tblusuarioperfil> obtenerTblUsuarioPerfil(Usuario _us, Perfil _per)
    {        
        try
        {
            EntityManager em = getEntityManager();                        
            
            List<Tblusuarioperfil> listUsusus = em.createNativeQuery("{call sp_selectUsuariosPerfil(?,?)}", Tblusuarioperfil.class).setParameter(1, _us.getIdUsuario()).setParameter(2, _per.getIdPerfil()).getResultList();                                                                                                          
                        
            em.close();
            return listUsusus;
        }
        catch(Exception ex )
        {
            System.out.print("el error es "+ ex.getMessage());
            return null;
        }        
    }
    
    public boolean actualizarTblusuarioperfil(Usuario _us, Perfil _per, Tblusuarioperfil _uspe)
    {
    
        try
        {                        
            EntityManager em = emf.createEntityManager();            
            // Create Call stored procedure
            em.getTransaction().begin();
            StoredProcedureQuery procedure = em.createStoredProcedureQuery("sp_updateEstadoTblUsuarioPerfil");            
            // Set Parameters
            procedure.registerStoredProcedureParameter("_fkUsuario", int.class, ParameterMode.IN);
            procedure.registerStoredProcedureParameter("_fkPerfil", int.class, ParameterMode.IN);
            procedure.registerStoredProcedureParameter("_estado", String.class, ParameterMode.IN);
            
            procedure.setParameter("_fkUsuario", _us.getIdUsuario());
            procedure.setParameter("_fkPerfil", _per.getIdPerfil());
            procedure.setParameter("_estado", _uspe.getEstado());
            
            // Execute SP
            int respuesta = procedure.executeUpdate();
            // Get Result                        
            em.getTransaction().commit();
            em.close(); 
            
            if(respuesta >0)
            {
                return true;
            }
            else
            {
                return false;
            }                        
        
        }
        catch(Exception ex)
        {
            System.out.print("el error es "+ ex.getMessage());
            return false; 
        
        }
    
    }
    
}
